哈希表，哈希算法（C语言）

最新推荐文章于 2024-08-29 15:32:55 发布
最新推荐文章于 2024-08-29 15:32:55 发布
阅读量1w 收藏 81
点赞数 11
分类专栏： 数据结构与算法 文章标签： c语言 函数 算法 海量数据
本文为博主原创文章，未经许可，不得转载，侵权必究。
本文链接：https://blog.csdn.net/qq_39630587/article/details/77196367
版权

哈希表

哈希表，又称散列表，常用于在海量数据中查找数据

哈希表中元素是由哈希函数确定的。将数据元素的关键字key作为自变量，通过一定的函数关系H(称为哈希函数)，计算出的值，即为该元素的存储地址。其优点是：运算速度快；缺点是：基于数组、难于扩展，不可遍历。

在建立一个哈希表之前需要解决两个主要问题:

  1. 构造均匀的哈希函数
    使H(key)均匀分布在哈希表中，以提高地址计算的速度。
    构造哈希函数的方法：直接定址法，数字分析法，平法折中法，折叠法，除留余数法，随机数法等。
  2. 处理冲突
    冲突是指在哈希表中，不同的关键字值对应到同一个存储位置的现象。即存在K1≠K2，但H(K1)=H(K2)。
    再均匀的哈希函数都只能可减少冲突，但不可能避免冲突。
    发生冲突后，必须解决，即必须寻找下一个可用地址。
    解决冲突的方法:开放地址法（包括线性探测，二次探测，随机探测），再哈希法，链地址法，建立公共溢出区等。

C语言实现

哈希表的数据结构

typedef struct HashNode_Struct HashNode;  
struct HashNode_Struct  {  
    char* sKey;//键值指针
    int nValue;  //键值
    HashNode* pNext; //指向下一个哈希结构
};

定义最大哈希长度及哈希数组

#define HASH_TABLE_MAX_SIZE 10000
HashNode* hashTable[HASH_TABLE_MAX_SIZE]; //哈希数组
int hash_table_size;  //当前哈希长度

哈希表初始化函数

void hash_table_init()  
{  
    hash_table_size = 0;  
    memset(hashTable, 0 , sizeof(HashNode*) * HASH_TABLE_MAX_SIZE);
    //memset(void *s,int c,size_t n); 
    //将s中后n个字节换成c所代表的内容 
    //该函数是对较大结构体或数组进行清零操作的一种最快的方法 
}

去符号化函数

unsigned int hash_table_hash_str(const char* skey)  
{  //无符号unsigned能保存2倍与有符号类型的正整型数据 
    const signed char *p = (const signed char*)skey; //常量 
    unsigned int h = *p;  
    if(h)
    {  
        for(p += 1; *p != '\0'; ++p)  
            h = (h << 5) - h + *p;  
    }  
    return h;  
}

插入函数

void hash_table_insert(const char* skey, int nvalue)  
{  
    if(hash_table_size >= HASH_TABLE_MAX_SIZE) //如果定义的哈希表长度大于等于最大长度 
    {  
        printf("内存溢出!\n");
        return;  
    }  

    unsigned int pos = hash_table_hash_str(skey) % HASH_TABLE_MAX_SIZE;  
  //用于解决冲突，pos为哈希函数 
    HashNode* pHead = hashTable[pos];
    while(pHead)
    {  
        if(strcmp(pHead->sKey, skey) == 0)  
        {  
            printf("%s发生冲突!\n", skey);
            return ;  
        }  
        pHead = pHead->pNext;  
    }  
    //动态建立结点，初始化，分配内存空间 
    HashNode* pNewNode = (HashNode*)malloc(sizeof(HashNode));  
    memset(pNewNode, 0, sizeof(HashNode));  
    pNewNode->sKey = (char*)malloc(sizeof(char) * (strlen(skey) + 1));  
    strcpy(pNewNode->sKey, skey);  
    pNewNode->nValue = nvalue;  

    //指针后移 
    pNewNode->pNext = hashTable[pos];  
    hashTable[pos] = pNewNode;  
    //表长增加 
    hash_table_size++;  
}

删除函数

void hash_table_remove(const char* skey)  
{  
    unsigned int pos = hash_table_hash_str(skey) % HASH_TABLE_MAX_SIZE; 

    if(hashTable[pos])  
    {  
        HashNode* pHead = hashTable[pos];  
        HashNode* pLast = NULL;  
        HashNode* pRemove = NULL;  
        while(pHead)  
        {  
            if(strcmp(skey, pHead->sKey) == 0)  
            {   //若str1==str2，则返回零;
                //若str1>str2，则返回正数;
                //若str1<str2，则返回负数。 
                pRemove = pHead;//若相等，用pRemove记录  
                break; 
            }  
            pLast = pHead;  //若不相等，不断后移 
            pHead = pHead->pNext;  
        }  
        if(pRemove)  
        {  
            if(pLast)
                pLast->pNext = pRemove->pNext;//实现删除1 
            else  
                hashTable[pos] = NULL;//实现删除2

            free(pRemove->sKey);  
            free(pRemove);  
        }  
    }  
}

查找函数

HashNode* hash_table_lookup(const char* skey)  
{  
    unsigned int pos = hash_table_hash_str(skey) % HASH_TABLE_MAX_SIZE;  

    if(hashTable[pos])  
    {  
        HashNode* pHead = hashTable[pos];  
        while(pHead)  
        {  
            if(strcmp(skey, pHead->sKey) == 0)  
                return pHead;//查找成功 

            pHead = pHead->pNext;  
        }  
    }  
    return NULL;  
}

打印哈希表函数

void hash_table_print()  
{ 
    int i;  
    for(i = 0; i < HASH_TABLE_MAX_SIZE; ++i)  
        if(hashTable[i])//表不空 
        {  
            HashNode* pHead = hashTable[i];  
            printf("%d=>", i);  
            while(pHead)  
            {  
                printf("%s:%d  ", pHead->sKey, pHead->nValue);  
                pHead = pHead->pNext;  
            }  
            printf("\n");  
        }  
}

释放内存函数

void hash_table_release()  
{  
    int i;  
    for(i = 0; i < HASH_TABLE_MAX_SIZE; ++i)  
    {  
        if(hashTable[i])  
        {  
            HashNode* pHead = hashTable[i];  
            while(pHead)  
            {  
                HashNode* pTemp = pHead;  
                pHead = pHead->pNext;  
                if(pTemp)  
                {  
                    free(pTemp->sKey);  
                    free(pTemp);  
                }  
                //逐个释放 
            }  
        }  
    }  
}

随机生成函数

#define MAX_STR_LEN 20  
#define MIN_STR_LEN 10  
void rand_str(char r[])  
{  
    int i;  
    int len = MIN_STR_LEN + rand() % (MAX_STR_LEN - MIN_STR_LEN);  
    for(i = 0; i < len - 1; ++i)  
        r[i] = 'a' + rand() % ( 'z' - 'a');  
    r[len - 1] = '\0';  
}

具体代码如下：

#include <stdio.h>  
#include <stdlib.h>  
#include <string.h>  
#include <time.h>  

#define HASH_TABLE_MAX_SIZE 10000  
typedef struct HashNode_Struct HashNode;  
struct HashNode_Struct  {  
    char* sKey;  
    int nValue;  
    HashNode* pNext;  
};  //哈希表数据结构 

HashNode* hashTable[HASH_TABLE_MAX_SIZE]; 
int hash_table_size;  //哈希表中键值对的数量 

//初始化哈希表 
void hash_table_init()  
{  
    hash_table_size = 0;  
    memset(hashTable, 0, sizeof(HashNode*) * HASH_TABLE_MAX_SIZE);
    //memset(void *s,int c,size_t n); 
    //将s中后n个字节换成c所代表的内容 
    //该函数是对较大结构体或数组进行清零操作的一种最快的方法 
}  


//去符号化哈希表  
unsigned int hash_table_hash_str(const char* skey)  
{  //无符号unsigned能保存2倍与有符号类型的正整型数据 
    const signed char *p = (const signed char*)skey; //常量 
    unsigned int h = *p;  
    if(h)
    {  
        for(p += 1; *p != '\0'; ++p)  
            h = (h << 5) - h + *p;  
    }  
    return h;  
}
//插入 
void hash_table_insert(const char* skey, int nvalue)  
{  
    if(hash_table_size >= HASH_TABLE_MAX_SIZE) //如果定义的哈希表长度大于等于最大长度 
    {  
        printf("内存溢出!\n");
        return;  
    }  

    unsigned int pos = hash_table_hash_str(skey) % HASH_TABLE_MAX_SIZE;  
  //用于解决冲突，pos为哈希函数 
    HashNode* pHead = hashTable[pos];
    while(pHead)
    {  
        if(strcmp(pHead->sKey, skey) == 0)  
        {  
            printf("%s发生冲突!\n", skey);
            return ;  
        }  
        pHead = pHead->pNext;  
    }  
    //动态建立结点，初始化，分配内存空间 
    HashNode* pNewNode = (HashNode*)malloc(sizeof(HashNode));  
    memset(pNewNode, 0, sizeof(HashNode));  
    pNewNode->sKey = (char*)malloc(sizeof(char) * (strlen(skey) + 1));  
    strcpy(pNewNode->sKey, skey);  
    pNewNode->nValue = nvalue;  

    //指针后移 
    pNewNode->pNext = hashTable[pos];  
    hashTable[pos] = pNewNode;  
    //表长增加 
    hash_table_size++;  
}  
//删除 
void hash_table_remove(const char* skey)  
{  
    unsigned int pos = hash_table_hash_str(skey) % HASH_TABLE_MAX_SIZE; 

    if(hashTable[pos])  
    {  
        HashNode* pHead = hashTable[pos];  
        HashNode* pLast = NULL;  
        HashNode* pRemove = NULL;  
        while(pHead)  
        {  
            if(strcmp(skey, pHead->sKey) == 0)  
            {   //若str1==str2，则返回零;
                //若str1>str2，则返回正数;
                //若str1<str2，则返回负数。 
                pRemove = pHead;//若相等，用pRemove记录  
                break; 
            }  
            pLast = pHead;  //若不相等，不断后移 
            pHead = pHead->pNext;  
        }  
        if(pRemove)  
        {  
            if(pLast)
                pLast->pNext = pRemove->pNext;//实现删除1 
            else  
                hashTable[pos] = NULL;//实现删除2

            free(pRemove->sKey);  
            free(pRemove);  
        }  
    }  
}  

//查找 
HashNode* hash_table_lookup(const char* skey)  
{  
    unsigned int pos = hash_table_hash_str(skey) % HASH_TABLE_MAX_SIZE;  

    if(hashTable[pos])  
    {  
        HashNode* pHead = hashTable[pos];  
        while(pHead)  
        {  
            if(strcmp(skey, pHead->sKey) == 0)  
                return pHead;//查找成功 

            pHead = pHead->pNext;  
        }  
    }  
    return NULL;  
}  

//打印 
void hash_table_print()  
{ 
    int i;  
    for(i = 0; i < HASH_TABLE_MAX_SIZE; ++i)  
        if(hashTable[i])//表不空 
        {  
            HashNode* pHead = hashTable[i];  
            printf("%d=>", i);  
            while(pHead)  
            {  
                printf("%s:%d  ", pHead->sKey, pHead->nValue);  
                pHead = pHead->pNext;  
            }  
            printf("\n");  
        }  
}  

//释放内存 
void hash_table_release()  
{  
    int i;  
    for(i = 0; i < HASH_TABLE_MAX_SIZE; ++i)  
    {  
        if(hashTable[i])  
        {  
            HashNode* pHead = hashTable[i];  
            while(pHead)  
            {  
                HashNode* pTemp = pHead;  
                pHead = pHead->pNext;  
                if(pTemp)  
                {  
                    free(pTemp->sKey);  
                    free(pTemp);  
                }  
                //逐个释放 
            }  
        }  
    }  
}  


/* ============================主测试函数============================*/  
#define MAX_STR_LEN 20  
#define MIN_STR_LEN 10  
void rand_str(char r[])  
{  
    int i;  
    int len = MIN_STR_LEN + rand() % (MAX_STR_LEN - MIN_STR_LEN);  
    for(i = 0; i < len - 1; ++i)  
        r[i] = 'a' + rand() % ( 'z' - 'a');  
    r[len - 1] = '\0';  
}  

int main(int argc, char** argv)  
{  
    srand(time(NULL));  
    hash_table_init();     
    int n = 10;  
    char str[MAX_STR_LEN + 1]; 
    const char *key1 = "aaa111";  
    const char *key2 = "bbb222";  
    const char *key3 = "ccc333";

    while(n--)  
    {  
        rand_str(str);  
        hash_table_insert(str, n);  
    }
    printf("插入前\n");
    hash_table_print(); 

    hash_table_insert(key1, 1);  
    hash_table_insert(key2, 2);  
    hash_table_insert(key3, 2);   

    printf("插入后\n");
    hash_table_print();  

    HashNode* pNode = hash_table_lookup(key1);  
    printf("查找结果:%d\n", pNode->nValue);  
    pNode = hash_table_lookup(key2);  
    printf("查找结果:%d\n", pNode->nValue);

    printf("删除之前:\n");  
    hash_table_print();  
    hash_table_remove(key3);  
    printf("删除之后:\n");  
    hash_table_print();  

    hash_table_release();  

    return 0;  
}
Rebright-崇明
关注
专栏目录
C语言实现hash算法
11-29
用C语言实现哈希算法，我是个初学者。是我自己编写的，有很多不好的地方懂行的人麻烦看一下，大家多交流
哈希算法C语言实现
02-17
哈希算法C语言实现
哈希（C语言）
最新发布
2303_82176667的博客
08-29 974
哈希算法是一种将任意长度的数据转换为固定长度的输出的算法。这种输出通常被称为哈希值或消息摘要。确定性：相同的输入总是产生相同的输出。快速计算：计算哈希值的速度通常很快。雪崩效应：输入的微小变化会导致输出的显著变化。抗碰撞性：找到两个不同的输入产生相同输出的情况非常困难。常见的哈希算法MD5SHA-1SHA-256SHA-3。
哈希（Hash）查找算法详解之C语言版
sunnyoldboy博客
10-16 1万+
哈希查找是一种快速查找算法，该算法不需要对关键字进行比较，而是以关键字为自变量，以该关键字在存储空间中的地址为因变量，建立某种函数关系，称为哈希函数，这样在查找某一关键字的时候，就可以通过哈希函数直接得到其地址，有效的提高了查找效率。 选取哈希函数及基本原则主要有：计算函数所需时间、关键字的长度、哈希表长度（哈希地址范围）、关键字分布情况、记录的查找频率等。 哈希函数的构造有多种，常见的有“直接定址法”、“数字分析法”、“平方取中法”、“折叠法”、“除留余数法”、“随机数法”等。
C语言-哈希查找(HASH)-详解（完整代码）
热门推荐
细雨青峦的博客
09-04 2万+
目录 原理： 实例解释 存储逻辑图 需要的知识： 附加 完整代码 代码详解 执行结果 1.查找个不存在的 2.查找个存在的 原理： 用一个指针数组，来存储 每个链表的头节点 的首地址 如果要从 'NUM' 个数中查找数据 先对'NUM'/0.75,求得最大质数'N' //(质数：只能被1和本身整除的数) 然后创建一个有'N'个元素的'指针数组' 然后将'NUM'个数分别对'N'取余 将每一个数保存在'余数'等于数组元素下标的链表中 然后进行查找是直接找对应的数组...
深入理解C语言中的哈希算法
深耕嵌入式领用多年， 致力于分享嵌入式领域技术!
04-22 897
深入理解C语言中的哈希算法
常用Hash算法(C语言的简单实现)
09-01
下面小编就为大家带来一篇常用Hash算法(C语言的简单实现)。小编觉得挺不错的，现在就分享给大家，也给大家做个参考。一起跟随小编过来看看吧
hashtab2_C语言_哈希表删除、添加、寻找_codeblocks_
10-04
在项目中，我们可以在Code::Blocks中编写、运行和测试哈希表的代码，利用其内置的调试工具检查变量的值，查看程序执行的步骤，从而更好地理解算法的运作。 在"hashtab2"这个项目中，开发者可能已经实现了上述功能，...
haxi.rar_C语言 哈希表_哈希表
09-24
哈希表算法实现的C语言源程序.cpp是实际的代码文件，其中包含哈希表的结构定义、哈希函数的实现、冲突解决策略以及相关的操作函数。例如，可能定义了一个结构体`hash_table`来存储哈希表，包含数组、大小、负载因子...
数据结构实验五哈希表设计c语言
04-25
在本实验中，我们实现了一个基本的哈希表查找算法。该算法首先根据学生姓名计算哈希值，然后定位到对应的链表，最后遍历链表以找到目标学生信息。 哈希表的应用 在本实验中，我们使用哈希表来存储学生信息，并实现...
哈希表实验C语言版实现
01-20
代码如下:/* 数据结构C语言版 哈希表 */#include <stdio>#include <malloc>#define NULLKEY 0 // 0为无记录标志 #define N 10 // 数据元素个数 typedef int KeyType;// 设关键字域为整型 typedef struct{ Key...
SHA256 哈希密码算法C语言实现
10-10
SHA256 哈希密码算法C语言实现 亲测好用。只要SHA256的实现。
哈希表操作（c语言版）
11-24
////采用除留余数法定义哈希表，哈希表长度为10，哈希函数为H(key)=key%13。产生冲突时采用线性探测法实现下面要求的功能。 ////（1）初始化哈希表,置空哈希表 ////（2）在哈希表中查找元素 ////（3）在哈希表中插入元素 ////（4）输出哈希表中所有元素 ////（5）建立Hash表
C语言下很实用的哈希算法
04-24
C语言下很实用的哈希算法，你可以将这个头文件加入C函数库中，也可以放入自己编写的程序文件夹中，直接#include即可使用。
C语言哈希查找实例
11-12
应用HASH算法的一个简单例子，包含哈希表的定义、创建、查找的实现，以及通过二次探测再散列解决冲突的冲突解决办法，麻雀虽小，五脏俱全
完整详细版 C语言版 数据结构与算法课程 第4章 哈希表（共49页）.ppt
10-06
在C语言版的数据结构与算法课程中，哈希表是第四章的重点内容。哈希表的概念是基于关键字与存储位置之间的映射关系，它能够快速定位数据，避免了线性搜索的时间消耗。 哈希函数是构建哈希表的核心，它的作用是将...
C语言实现哈希搜索算法
shiwei0813的博客
08-16 1115
线性探测法（Linear Probing）：使用一个数组存储整个哈希表，在发生哈希碰撞时，从当前位置开始向后依次查找第一个空闲的位置，并将元素插入到该位置中，当需要查找某个元素时，首先计算出该元素的哈希值，并定位到对应的位置，如果该位置为空，则说明目标元素不存在于哈希表中；否则，如果该位置存储的元素与目标元素相同，则直接返回；需要注意的是，哈希表的实现涉及到很多细节问题，比如哈希函数、冲突解决方法等，如果没有特殊需求，可以使用已经实现好的哈希表库，例如C++ STL库中的 unordered_map 类。
【C语言】算法学习·哈希算法全解
m0_64560763的博客
07-26 5185
c语言哈希算法
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值